package org.simpleframework.util;

import java.io.File;
import java.io.FileFilter;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.net.URL;
import java.util.HashSet;
import java.util.Set;
import lombok.extern.slf4j.Slf4j;

/**
 * @Author: yu.zhou
 * @DateTime: 2023/01/04 10:14
 * <p>
 * 操作类的工具类
 */
@Slf4j
public class ClassUtil {

    public static final String FILE_PROTOCOL = "file";

    /**
     * 获取当前包下的所有类信息
     *
     * @param packageName 包名
     * @return 类集合
     */
    public static Set<Class<?>> extractPageClass(String packageName) {
        // 1.获取类加载器
        ClassLoader classLoad = getClassLoad();
        // 2.通过类加载器获取加载的资源信息
        URL url = classLoad.getResource(packageName.replace(".", "/"));
        if (url == null) {
            log.warn("unable to retrieve anything from package" + packageName);
            return null;
        }
        // 3.依据不同的资源类型,采用不同方式获取资源的集合
        Set<Class<?>> classSet = null;
        // 过滤文件类型的资源
        if (FILE_PROTOCOL.equalsIgnoreCase(url.getProtocol())) {
            classSet = new HashSet<>();
            // file 为一个目录,遍历当前目录下的文件
            File packageDirectory = new File(url.getFile().replace("%20", " "));
            extractClassFile(classSet, packageDirectory, packageName);
        }
        // TODO 此处可以加入对其他资源处理的逻辑

        return classSet;
    }

    /**
     * 递归获取目标package里的所有class(包括子包的class)
     *
     * @param emptySet    结果集
     * @param fileSource  资源文件或者目录
     * @param packageName 包名
     */
    private static void extractClassFile(Set<Class<?>> emptySet, File fileSource, String packageName) {
        if (!fileSource.isDirectory()) {
            return;
        }
        // 获取当前的文件夹下的所有文件
        File[] files = fileSource.listFiles(new FileFilter() {
            @Override
            public boolean accept(File file) {
                // 过滤出当前目录下的目录就直接放行,class文件就加载到set中,都不满足就过滤掉
                if (file.isDirectory()) {
                    return true;
                } else {
                    // 获取文件的绝对路径
                    String absoluteFilePath = file.getAbsolutePath();
                    if (absoluteFilePath.endsWith(".class")) {
                        // 若是class文件直接加载
                        addToClassSet(absoluteFilePath);
                    }
                }
                return false;
            }

            /**
             * 根据获取的class的绝对值路径获取并生成class对象,并放入classSet中
             *
             * @param absoluteFilePath class文件的绝对路径
             */
            private void addToClassSet(String absoluteFilePath) {
                // 1.根据class文件的绝对值路径
                absoluteFilePath = absoluteFilePath.replace(File.separator, ".");
                // 2.利用反射获取class对象加入到classSet中
                String className = absoluteFilePath.substring(absoluteFilePath.indexOf(packageName));
                className = className.substring(0, className.lastIndexOf("."));

                // 获取的class对象
                Class<?> targetClass = loadClass(className);
                emptySet.add(targetClass);
            }
        });

        // 递归遍历
        if (files != null && files.length > 0) {
            for (File file : files) {
                extractClassFile(emptySet, file, packageName);
            }
        }

    }

    /**
     * 获取当前线程的类加载器
     *
     * @return
     */
    public static ClassLoader getClassLoad() {
        return Thread.currentThread().getContextClassLoader();
    }

    /**
     * 获取class对象
     *
     * @param classPath = package+类名
     * @return class
     */
    public static Class<?> loadClass(String classPath) {
        try {
            return Class.forName(classPath);
        } catch (ClassNotFoundException e) {
            log.error("load class error", e);
            throw new RuntimeException(e);
        }
    }

    /**
     * 实例化class
     *
     * @param clazz      字节码对象
     * @param accessible 是否支持创建出私有对象的实例
     * @param <T>        被创建的类型
     * @return
     */
    public static <T> T newInstance(Class<?> clazz, boolean accessible) {
        try {
            Constructor<?> constructor = clazz.getDeclaredConstructor();
            constructor.setAccessible(accessible);
            return (T) constructor.newInstance();
        } catch (Exception e) {
            log.error("newInstance error", e);
            throw new RuntimeException(e);
        }
    }

    /**
     * @param target     类实例
     * @param field      成员变量
     * @param value      成员变量的值
     * @param accessible 是否允许设置私有属性
     */
    public static void setFiled(Object target, Field field, Object value, boolean accessible) {
        field.setAccessible(accessible);
        try {
            field.set(target, value);
        } catch (IllegalAccessException e) {
            log.error("setFiled error", e);
            throw new RuntimeException(e);
        }
    }

    public static void main(String[] args) {
        File file = new File("com.zyy.entity");
        System.out.println(file.isDirectory());
    }
}
